home *** CD-ROM | disk | FTP | other *** search
/ Champak 52 / Volume 52 - JOGO DISK .iso / Games / scoobysnackmachine.swf / scripts / __Packages / mx / transitions / Tween.as < prev   
Encoding:
Text File  |  2007-10-01  |  22.8 KB  |  683 lines

  1. var ┬º\x01┬º = 330;
  2. while(true)
  3. {
  4.    if(eval("\x01") == 330)
  5.    {
  6.       set("\x01",eval("\x01") - 325);
  7.       ┬º┬ºpush(true);
  8.    }
  9.    else if(eval("\x01") == 703)
  10.    {
  11.       set("\x01",eval("\x01") - 422);
  12.    }
  13.    else if(eval("\x01") == 42)
  14.    {
  15.       set("\x01",eval("\x01") + 894);
  16.    }
  17.    else if(eval("\x01") == 774)
  18.    {
  19.       set("\x01",eval("\x01") + 162);
  20.    }
  21.    else
  22.    {
  23.       if(eval("\x01") == 232)
  24.       {
  25.          set("\x01",eval("\x01") + 33);
  26.          if(!_global.mx)
  27.          {
  28.             _global.mx = new Object();
  29.          }
  30.          ┬º┬ºpop();
  31.          if(!_global.mx.transitions)
  32.          {
  33.             _global.mx.transitions = new Object();
  34.          }
  35.          ┬º┬ºpop();
  36.          if(!_global.mx.transitions.Tween)
  37.          {
  38.             var _loc2_ = mx.transitions.Tween = function(obj, prop, func, begin, finish, duration, useSeconds)
  39.             {
  40.                mx.transitions.OnEnterFrameBeacon.init();
  41.                if(!arguments.length)
  42.                {
  43.                   return undefined;
  44.                }
  45.                this.obj = obj;
  46.                this.prop = prop;
  47.                this.begin = begin;
  48.                this.position = begin;
  49.                this.duration = duration;
  50.                this.useSeconds = useSeconds;
  51.                if(func)
  52.                {
  53.                   this.func = func;
  54.                }
  55.                this.finish = finish;
  56.                this._listeners = [];
  57.                this.addListener(this);
  58.                this.start();
  59.             }.prototype;
  60.             _loc2_.__set__time = function(t)
  61.             {
  62.                this.prevTime = this._time;
  63.                if(t > this.duration)
  64.                {
  65.                   if(this.looping)
  66.                   {
  67.                      this.rewind(t - this._duration);
  68.                      this.update();
  69.                      this.broadcastMessage("onMotionLooped",this);
  70.                   }
  71.                   else
  72.                   {
  73.                      if(this.useSeconds)
  74.                      {
  75.                         this._time = this._duration;
  76.                         this.update();
  77.                      }
  78.                      this.stop();
  79.                      this.broadcastMessage("onMotionFinished",this);
  80.                   }
  81.                }
  82.                else if(t < 0)
  83.                {
  84.                   this.rewind();
  85.                   this.update();
  86.                }
  87.                else
  88.                {
  89.                   this._time = t;
  90.                   this.update();
  91.                }
  92.                return this.time;
  93.             };
  94.             _loc2_.__get__time = function()
  95.             {
  96.                return this._time;
  97.             };
  98.             _loc2_.__set__duration = function(d)
  99.             {
  100.                this._duration = !(d == null || d <= 0) ? d : _global.Infinity;
  101.                return this.duration;
  102.             };
  103.             _loc2_.__get__duration = function()
  104.             {
  105.                return this._duration;
  106.             };
  107.             _loc2_.__set__FPS = function(fps)
  108.             {
  109.                var _loc2_ = this.isPlaying;
  110.                this.stopEnterFrame();
  111.                this._fps = fps;
  112.                if(_loc2_)
  113.                {
  114.                   this.startEnterFrame();
  115.                }
  116.                return this.FPS;
  117.             };
  118.             _loc2_.__get__FPS = function()
  119.             {
  120.                return this._fps;
  121.             };
  122.             _loc2_.__set__position = function(p)
  123.             {
  124.                this.setPosition(p);
  125.                return this.position;
  126.             };
  127.             _loc2_.setPosition = function(p)
  128.             {
  129.                this.prevPos = this._pos;
  130.                this.obj[this.prop] = this._pos = p;
  131.                this.broadcastMessage("onMotionChanged",this,this._pos);
  132.                updateAfterEvent();
  133.             };
  134.             _loc2_.__get__position = function()
  135.             {
  136.                return this.getPosition();
  137.             };
  138.             _loc2_.getPosition = function(t)
  139.             {
  140.                if(t == undefined)
  141.                {
  142.                   t = this._time;
  143.                }
  144.                return this.func(t,this.begin,this.change,this._duration);
  145.             };
  146.             _loc2_.__set__finish = function(f)
  147.             {
  148.                this.change = f - this.begin;
  149.                return this.finish;
  150.             };
  151.             _loc2_.__get__finish = function()
  152.             {
  153.                return this.begin + this.change;
  154.             };
  155.             _loc2_.continueTo = function(finish, duration)
  156.             {
  157.                this.begin = this.position;
  158.                this.finish = finish;
  159.                if(duration != undefined)
  160.                {
  161.                   this.duration = duration;
  162.                }
  163.                this.start();
  164.             };
  165.             _loc2_.yoyo = function()
  166.             {
  167.                this.continueTo(this.begin,this.time);
  168.             };
  169.             _loc2_.startEnterFrame = function()
  170.             {
  171.                if(this._fps == undefined)
  172.                {
  173.                   _global.MovieClip.addListener(this);
  174.                }
  175.                else
  176.                {
  177.                   this._intervalID = setInterval(this,"onEnterFrame",1000 / this._fps);
  178.                }
  179.                this.isPlaying = true;
  180.             };
  181.             _loc2_.stopEnterFrame = function()
  182.             {
  183.                if(this._fps == undefined)
  184.                {
  185.                   _global.MovieClip.removeListener(this);
  186.                }
  187.                else
  188.                {
  189.                   clearInterval(this._intervalID);
  190.                }
  191.                this.isPlaying = false;
  192.             };
  193.             _loc2_.start = function()
  194.             {
  195.                this.rewind();
  196.                this.startEnterFrame();
  197.                this.broadcastMessage("onMotionStarted",this);
  198.             };
  199.             _loc2_.stop = function()
  200.             {
  201.                this.stopEnterFrame();
  202.                this.broadcastMessage("onMotionStopped",this);
  203.             };
  204.             _loc2_.resume = function()
  205.             {
  206.                this.fixTime();
  207.                this.startEnterFrame();
  208.                this.broadcastMessage("onMotionResumed",this);
  209.             };
  210.             _loc2_.rewind = function(t)
  211.             {
  212.                this._time = t != undefined ? t : 0;
  213.                this.fixTime();
  214.                this.update();
  215.             };
  216.             _loc2_.fforward = function()
  217.             {
  218.                this.time = this._duration;
  219.                this.fixTime();
  220.             };
  221.             _loc2_.nextFrame = function()
  222.             {
  223.                if(this.useSeconds)
  224.                {
  225.                   this.time = (getTimer() - this._startTime) / 1000;
  226.                }
  227.                else
  228.                {
  229.                   this.time = this._time + 1;
  230.                }
  231.             };
  232.             _loc2_.onEnterFrame = function()
  233.             {
  234.                this.nextFrame();
  235.             };
  236.             _loc2_.prevFrame = function()
  237.             {
  238.                if(!this.useSeconds)
  239.                {
  240.                   this.time = this._time - 1;
  241.                }
  242.             };
  243.             _loc2_.toString = function()
  244.             {
  245.                return "[Tween]";
  246.             };
  247.             _loc2_.fixTime = function()
  248.             {
  249.                if(this.useSeconds)
  250.                {
  251.                   this._startTime = getTimer() - this._time * 1000;
  252.                }
  253.             };
  254.             _loc2_.update = function()
  255.             {
  256.                this.position = this.getPosition(this._time);
  257.             };
  258.             mx.transitions.Tween = function(obj, prop, func, begin, finish, duration, useSeconds)
  259.             {
  260.                mx.transitions.OnEnterFrameBeacon.init();
  261.                if(!arguments.length)
  262.                {
  263.                   return undefined;
  264.                }
  265.                this.obj = obj;
  266.                this.prop = prop;
  267.                this.begin = begin;
  268.                this.position = begin;
  269.                this.duration = duration;
  270.                this.useSeconds = useSeconds;
  271.                if(func)
  272.                {
  273.                   this.func = func;
  274.                }
  275.                this.finish = finish;
  276.                this._listeners = [];
  277.                this.addListener(this);
  278.                this.start();
  279.             }.version = "1.1.0.52";
  280.             mx.transitions.Tween = function(obj, prop, func, begin, finish, duration, useSeconds)
  281.             {
  282.                mx.transitions.OnEnterFrameBeacon.init();
  283.                if(!arguments.length)
  284.                {
  285.                   return undefined;
  286.                }
  287.                this.obj = obj;
  288.                this.prop = prop;
  289.                this.begin = begin;
  290.                this.position = begin;
  291.                this.duration = duration;
  292.                this.useSeconds = useSeconds;
  293.                if(func)
  294.                {
  295.                   this.func = func;
  296.                }
  297.                this.finish = finish;
  298.                this._listeners = [];
  299.                this.addListener(this);
  300.                this.start();
  301.             }.__initBeacon = mx.transitions.OnEnterFrameBeacon.init();
  302.             mx.transitions.Tween = function(obj, prop, func, begin, finish, duration, useSeconds)
  303.             {
  304.                mx.transitions.OnEnterFrameBeacon.init();
  305.                if(!arguments.length)
  306.                {
  307.                   return undefined;
  308.                }
  309.                this.obj = obj;
  310.                this.prop = prop;
  311.                this.begin = begin;
  312.                this.position = begin;
  313.                this.duration = duration;
  314.                this.useSeconds = useSeconds;
  315.                if(func)
  316.                {
  317.                   this.func = func;
  318.                }
  319.                this.finish = finish;
  320.                this._listeners = [];
  321.                this.addListener(this);
  322.                this.start();
  323.             }.__initBroadcaster = mx.transitions.BroadcasterMX.initialize(mx.transitions.Tween.prototype,true);
  324.             _loc2_.func = function(t, b, c, d)
  325.             {
  326.                return c * t / d + b;
  327.             };
  328.             ┬º┬ºpush(_loc2_.addProperty("FPS",_loc2_.__get__FPS,_loc2_.__set__FPS));
  329.             ┬º┬ºpush(_loc2_.addProperty("duration",_loc2_.__get__duration,_loc2_.__set__duration));
  330.             ┬º┬ºpush(_loc2_.addProperty("finish",_loc2_.__get__finish,_loc2_.__set__finish));
  331.             ┬º┬ºpush(_loc2_.addProperty("position",_loc2_.__get__position,_loc2_.__set__position));
  332.             ┬º┬ºpush(_loc2_.addProperty("time",_loc2_.__get__time,_loc2_.__set__time));
  333.             ┬º┬ºpush(ASSetPropFlags(mx.transitions.Tween.prototype,null,1));
  334.          }
  335.          ┬º┬ºpop();
  336.          break;
  337.       }
  338.       if(eval("\x01") == 607)
  339.       {
  340.          set("\x01",eval("\x01") - 326);
  341.       }
  342.       else if(eval("\x01") == 281)
  343.       {
  344.          set("\x01",eval("\x01") - 49);
  345.       }
  346.       else
  347.       {
  348.          if(eval("\x01") == 932)
  349.          {
  350.             set("\x01",eval("\x01") - 229);
  351.             break;
  352.          }
  353.          if(eval("\x01") == 142)
  354.          {
  355.             set("\x01",eval("\x01") + 790);
  356.             if(┬º┬ºpop())
  357.             {
  358.                set("\x01",eval("\x01") - 229);
  359.             }
  360.          }
  361.          else
  362.          {
  363.             if(eval("\x01") == 348)
  364.             {
  365.                set("\x01",eval("\x01") - 306);
  366.                ┬º┬ºpop() === ┬º┬ºpop();
  367.                ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop();
  368.                _loc2_.onMotionLooped = function()
  369.                {
  370.                };
  371.                _loc2_.broadcastMessage = function()
  372.                {
  373.                };
  374.                _loc2_.stop = function()
  375.                {
  376.                };
  377.                _loc2_.onMotionFinished = function()
  378.                {
  379.                   super.onMotionFinished();
  380.                   this.prevTime.time;
  381.                   this._time.time;
  382.                };
  383.                _loc2_.Infinity = function()
  384.                {
  385.                   super.Infinity();
  386.                   this.prevTime.__set__FPS();
  387.                   this._time.__set__FPS();
  388.                };
  389.                _loc2_.isPlaying = function()
  390.                {
  391.                   _listeners.addListener().stopEnterFrame(this);
  392.                   this.prevTime.time;
  393.                   this._time.time;
  394.                   this.Tween.startEnterFrame(_listeners._fps);
  395.                   this.Tween.FPS;
  396.                   delete this.Tween;
  397.                   delete this.prevTime;
  398.                   delete this._time;
  399.                };
  400.                _loc2_.setPosition = function()
  401.                {
  402.                   return this.Object;
  403.                };
  404.                _loc2_.__get__position = function()
  405.                {
  406.                   if(this.prevPos == undefined)
  407.                   {
  408.                      this.prevPos = 0;
  409.                   }
  410.                   return this.prevPos;
  411.                };
  412.                _loc2_._pos = function()
  413.                {
  414.                   return this.onMotionChanged;
  415.                };
  416.                _loc2_.updateAfterEvent = function()
  417.                {
  418.                   return this.getPosition;
  419.                };
  420.                _loc2_.change = function()
  421.                {
  422.                   return this.finish.continueTo.position;
  423.                };
  424.                _loc2_.__get__finish = function()
  425.                {
  426.                   return this.Tween;
  427.                };
  428.                _loc2_.rewind = function(__nXStrength, __nYStrength)
  429.                {
  430.                   if(!this.yoyo)
  431.                   {
  432.                      var _loc2_ = 100 - looping._duration(__nXStrength) * mx.MovieClip;
  433.                      var _loc3_ = 100 - looping._duration(__nYStrength) * mx._intervalID;
  434.                      if(_loc2_ < mx.onEnterFrame || _loc2_ > 100)
  435.                      {
  436.                         _loc2_ = mx.onEnterFrame;
  437.                      }
  438.                      if(_loc3_ < mx.setInterval || _loc3_ > 100)
  439.                      {
  440.                         _loc3_ = mx.setInterval;
  441.                      }
  442.                      this.removeListener();
  443.                      if(this.prevTime != undefined)
  444.                      {
  445.                         this.prevTime.time;
  446.                      }
  447.                      if(this._time != undefined)
  448.                      {
  449.                         this._time.time;
  450.                      }
  451.                      this.prevTime = new onMotionStarted.onMotionStopped.fforward(this.Tween,"OnEnterFrameBeacon",onMotionStarted.onMotionStopped.resume.fixTime.onMotionResumed,_loc2_,this.Tween.OnEnterFrameBeacon,mx.clearInterval,false);
  452.                      this._time = new onMotionStarted.onMotionStopped.fforward(this.Tween,"length",onMotionStarted.onMotionStopped.resume.fixTime.onMotionResumed,_loc3_,this.Tween.length,mx.clearInterval,false);
  453.                      this.prevTime.nextFrame(this.obj);
  454.                      this._time.nextFrame(this.obj);
  455.                   }
  456.                };
  457.                _loc2_.removeListener = function()
  458.                {
  459.                   this.Tween.OnEnterFrameBeacon = this.transitions;
  460.                   this.Tween.length = this.init;
  461.                };
  462.                mx.transitions.Tween = function(obj, prop, func, begin, finish, duration, useSeconds)
  463.                {
  464.                   mx.transitions.OnEnterFrameBeacon.init();
  465.                   if(!arguments.length)
  466.                   {
  467.                      return undefined;
  468.                   }
  469.                   this.obj = obj;
  470.                   this.prop = prop;
  471.                   this.begin = begin;
  472.                   this.position = begin;
  473.                   this.duration = duration;
  474.                   this.useSeconds = useSeconds;
  475.                   if(func)
  476.                   {
  477.                      this.func = func;
  478.                   }
  479.                   this.finish = finish;
  480.                   this._listeners = [];
  481.                   this.addListener(this);
  482.                   this.start();
  483.                }.clearInterval = 15;
  484.                mx.transitions.Tween = function(obj, prop, func, begin, finish, duration, useSeconds)
  485.                {
  486.                   mx.transitions.OnEnterFrameBeacon.init();
  487.                   if(!arguments.length)
  488.                   {
  489.                      return undefined;
  490.                   }
  491.                   this.obj = obj;
  492.                   this.prop = prop;
  493.                   this.begin = begin;
  494.                   this.position = begin;
  495.                   this.duration = duration;
  496.                   this.useSeconds = useSeconds;
  497.                   if(func)
  498.                   {
  499.                      this.func = func;
  500.                   }
  501.                   this.finish = finish;
  502.                   this._listeners = [];
  503.                   this.addListener(this);
  504.                   this.start();
  505.                }.setInterval = 65;
  506.                mx.transitions.Tween = function(obj, prop, func, begin, finish, duration, useSeconds)
  507.                {
  508.                   mx.transitions.OnEnterFrameBeacon.init();
  509.                   if(!arguments.length)
  510.                   {
  511.                      return undefined;
  512.                   }
  513.                   this.obj = obj;
  514.                   this.prop = prop;
  515.                   this.begin = begin;
  516.                   this.position = begin;
  517.                   this.duration = duration;
  518.                   this.useSeconds = useSeconds;
  519.                   if(func)
  520.                   {
  521.                      this.func = func;
  522.                   }
  523.                   this.finish = finish;
  524.                   this._listeners = [];
  525.                   this.addListener(this);
  526.                   this.start();
  527.                }.onEnterFrame = 60;
  528.                mx.transitions.Tween = function(obj, prop, func, begin, finish, duration, useSeconds)
  529.                {
  530.                   mx.transitions.OnEnterFrameBeacon.init();
  531.                   if(!arguments.length)
  532.                   {
  533.                      return undefined;
  534.                   }
  535.                   this.obj = obj;
  536.                   this.prop = prop;
  537.                   this.begin = begin;
  538.                   this.position = begin;
  539.                   this.duration = duration;
  540.                   this.useSeconds = useSeconds;
  541.                   if(func)
  542.                   {
  543.                      this.func = func;
  544.                   }
  545.                   this.finish = finish;
  546.                   this._listeners = [];
  547.                   this.addListener(this);
  548.                   this.start();
  549.                }._intervalID = 2;
  550.                mx.transitions.Tween = function(obj, prop, func, begin, finish, duration, useSeconds)
  551.                {
  552.                   mx.transitions.OnEnterFrameBeacon.init();
  553.                   if(!arguments.length)
  554.                   {
  555.                      return undefined;
  556.                   }
  557.                   this.obj = obj;
  558.                   this.prop = prop;
  559.                   this.begin = begin;
  560.                   this.position = begin;
  561.                   this.duration = duration;
  562.                   this.useSeconds = useSeconds;
  563.                   if(func)
  564.                   {
  565.                      this.func = func;
  566.                   }
  567.                   this.finish = finish;
  568.                   this._listeners = [];
  569.                   this.addListener(this);
  570.                   this.start();
  571.                }.MovieClip = 2;
  572.                __initBroadcaster(_global.mx.__set__time,null,1);
  573.                ┬º┬ºpush(_loc2_.prevFrame("_startTime",_loc2_.setPosition,function()
  574.                {
  575.                }
  576.                ));
  577.                ┬º┬ºpush(_loc2_.prevFrame("toString",_loc2_.updateAfterEvent,function()
  578.                {
  579.                }
  580.                ));
  581.                ┬º┬ºpush(_loc2_.prevFrame("[Tween]",_loc2_.__get__position,function()
  582.                {
  583.                }
  584.                ));
  585.                ┬º┬ºpush(_loc2_.prevFrame("version",_loc2_.change,function()
  586.                {
  587.                }
  588.                ));
  589.                ┬º┬ºpush(_loc2_.prevFrame("1.1.0.52",_loc2_._pos,function()
  590.                {
  591.                }
  592.                ));
  593.                ┬º┬ºpush(_loc2_.prevFrame("__initBeacon",_loc2_.__get__finish,function()
  594.                {
  595.                }
  596.                ));
  597.                break;
  598.             }
  599.             if(eval("\x01") == 421)
  600.             {
  601.                set("\x01",eval("\x01") - 165);
  602.                if(┬º┬ºpop())
  603.                {
  604.                   set("\x01",eval("\x01") + 707);
  605.                }
  606.             }
  607.             else if(eval("\x01") == 668)
  608.             {
  609.                set("\x01",eval("\x01") - 526);
  610.                ┬º┬ºpush(true);
  611.             }
  612.             else if(eval("\x01") == 850)
  613.             {
  614.                set("\x01",eval("\x01") - 182);
  615.             }
  616.             else if(eval("\x01") == 936)
  617.             {
  618.                set("\x01",eval("\x01") - 515);
  619.                ┬º┬ºpush(true);
  620.             }
  621.             else if(eval("\x01") == 349)
  622.             {
  623.                set("\x01",eval("\x01") - 1);
  624.                if(┬º┬ºpop())
  625.                {
  626.                   set("\x01",eval("\x01") - 306);
  627.                }
  628.             }
  629.             else if(eval("\x01") == 963)
  630.             {
  631.                set("\x01",eval("\x01") - 295);
  632.             }
  633.             else if(eval("\x01") == 761)
  634.             {
  635.                set("\x01",eval("\x01") - 133);
  636.             }
  637.             else
  638.             {
  639.                if(eval("\x01") == 256)
  640.                {
  641.                   set("\x01",eval("\x01") + 707);
  642.                   break;
  643.                }
  644.                if(eval("\x01") == 628)
  645.                {
  646.                   set("\x01",eval("\x01") - 279);
  647.                   ┬º┬ºpush(true);
  648.                }
  649.                else
  650.                {
  651.                   if(eval("\x01") == 265)
  652.                   {
  653.                      set("\x01",eval("\x01") - 265);
  654.                      break;
  655.                   }
  656.                   if(eval("\x01") == 552)
  657.                   {
  658.                      set("\x01",eval("\x01") + 76);
  659.                   }
  660.                   else
  661.                   {
  662.                      if(eval("\x01") == 168)
  663.                      {
  664.                         set("\x01",eval("\x01") + 384);
  665.                         break;
  666.                      }
  667.                      if(eval("\x01") != 5)
  668.                      {
  669.                         break;
  670.                      }
  671.                      set("\x01",eval("\x01") + 163);
  672.                      if(┬º┬ºpop())
  673.                      {
  674.                         set("\x01",eval("\x01") + 384);
  675.                      }
  676.                   }
  677.                }
  678.             }
  679.          }
  680.       }
  681.    }
  682. }
  683.